@fieldwangai/agentflow 0.1.71 → 0.1.73

package/bin/lib/admin-storage-config.mjs

@@ -7,7 +7,10 @@ import {
   expandAgentflowHomePath,
   getAgentflowDataRoot,
   getAgentflowDataRootOverride,
+  getAgentflowSkillsRoot,
+  getAgentflowSkillsRootOverride,
   writeAgentflowDataRootOverride,
+  writeAgentflowSkillsRootOverride,
 } from "./paths.mjs";
 
 function defaultAgentflowDataRoot() {
@@ -28,6 +31,14 @@ function normalizeDataRoot(raw) {
   return dataRoot;
 }
 
+function normalizeSkillsRoot(raw) {
+  const skillsRoot = expandAgentflowHomePath(raw);
+  if (skillsRoot && !path.isAbsolute(skillsRoot)) {
+    throw new Error("skillsRoot must be an absolute path");
+  }
+  return skillsRoot;
+}
+
 function copyEntry(src, dest) {
   const stat = fs.lstatSync(src);
   if (stat.isSymbolicLink()) {
@@ -45,6 +56,12 @@ function copyEntry(src, dest) {
   fs.copyFileSync(src, dest);
 }
 
+function copyEntryIfMissing(src, dest) {
+  if (fs.existsSync(dest)) return false;
+  copyEntry(src, dest);
+  return true;
+}
+
 function migrateDataRoot(oldRoot, newRoot) {
   const from = path.resolve(oldRoot);
   const to = path.resolve(newRoot);
@@ -63,9 +80,49 @@ function migrateDataRoot(oldRoot, newRoot) {
   return { migrated: true, copied: true };
 }
 
+function legacyCodexSkillsRoot() {
+  return path.join(os.homedir(), ".codex", "skills");
+}
+
+function migrateSkillsRoot(oldRoot, newRoot) {
+  const from = path.resolve(oldRoot);
+  const to = path.resolve(newRoot);
+  if (from === to) return { migrated: false, copied: false };
+  if (pathInside(from, to)) {
+    throw new Error("skillsRoot target cannot be inside the current skills root");
+  }
+  if (pathInside(to, from)) {
+    throw new Error("skillsRoot target cannot be a parent of the current skills root");
+  }
+  fs.mkdirSync(to, { recursive: true });
+  if (!fs.existsSync(from)) return { migrated: true, copied: false };
+  for (const name of fs.readdirSync(from)) {
+    copyEntry(path.join(from, name), path.join(to, name));
+  }
+  return { migrated: true, copied: true };
+}
+
+function migrateLegacyCodexSkills(targetRoot) {
+  const from = legacyCodexSkillsRoot();
+  const to = path.resolve(targetRoot);
+  const source = path.resolve(from);
+  if (source === to || !fs.existsSync(source)) return { migrated: false, copied: 0, source };
+  if (pathInside(source, to) || pathInside(to, source)) return { migrated: false, copied: 0, source };
+  fs.mkdirSync(to, { recursive: true });
+  let copied = 0;
+  for (const name of fs.readdirSync(source)) {
+    if (copyEntryIfMissing(path.join(source, name), path.join(to, name))) copied += 1;
+  }
+  return { migrated: copied > 0, copied, source };
+}
+
 export function readAdminStorageConfig() {
   const envDataRoot = normalizeDataRoot(process.env.AGENTFLOW_HOME || "");
+  const envSkillsRoot = normalizeSkillsRoot(process.env.AGENTFLOW_SKILLS_ROOT || "");
   const configuredDataRoot = getAgentflowDataRootOverride();
+  const configuredSkillsRoot = getAgentflowSkillsRootOverride();
+  const skillsRoot = getAgentflowSkillsRoot();
+  const legacySkillsRoot = legacyCodexSkillsRoot();
   return {
     version: 1,
     dataRoot: getAgentflowDataRoot(),
@@ -73,21 +130,49 @@ export function readAdminStorageConfig() {
     defaultDataRoot: defaultAgentflowDataRoot(),
     envDataRoot,
     envLocked: Boolean(envDataRoot),
+    skillsRoot,
+    configuredSkillsRoot,
+    defaultSkillsRoot: path.join(getAgentflowDataRoot(), "skills"),
+    envSkillsRoot,
+    skillsEnvLocked: Boolean(envSkillsRoot),
+    legacySkillsRoot,
+    legacySkillsRootExists: fs.existsSync(legacySkillsRoot),
     configPath: AGENTFLOW_HOME_CONFIG_PATH,
   };
 }
 
 export function writeAdminStorageConfig(config = {}) {
   const current = readAdminStorageConfig();
-  if (current.envLocked) {
-    throw new Error("AGENTFLOW_HOME is set; update the environment variable instead of Admin Settings");
-  }
   const nextRoot = normalizeDataRoot(config.dataRoot ?? "");
   if (!nextRoot) throw new Error("dataRoot is required");
-  const migration = migrateDataRoot(current.dataRoot, nextRoot);
-  writeAgentflowDataRootOverride(nextRoot);
+  let migration = { migrated: false, copied: false };
+  if (current.envLocked) {
+    if (path.resolve(nextRoot) !== path.resolve(current.dataRoot)) {
+      throw new Error("AGENTFLOW_HOME is set; update the environment variable instead of Admin Settings");
+    }
+  } else {
+    migration = migrateDataRoot(current.dataRoot, nextRoot);
+    writeAgentflowDataRootOverride(nextRoot);
+  }
+  const afterDataRoot = readAdminStorageConfig();
+  if (afterDataRoot.skillsEnvLocked) {
+    return {
+      ...afterDataRoot,
+      migration,
+      skillsMigration: { skipped: true, reason: "AGENTFLOW_SKILLS_ROOT is set" },
+    };
+  }
+  const nextSkillsRoot = normalizeSkillsRoot(config.skillsRoot ?? afterDataRoot.defaultSkillsRoot);
+  if (!nextSkillsRoot) throw new Error("skillsRoot is required");
+  const skillsMigration = migrateSkillsRoot(current.skillsRoot, nextSkillsRoot);
+  writeAgentflowSkillsRootOverride(nextSkillsRoot);
+  const legacySkillsMigration = config.migrateLegacySkills === false
+    ? { migrated: false, copied: 0, source: legacyCodexSkillsRoot(), skipped: true }
+    : migrateLegacyCodexSkills(nextSkillsRoot);
   return {
     ...readAdminStorageConfig(),
     migration,
+    skillsMigration,
+    legacySkillsMigration,
   };
 }

package/bin/lib/composer-skill-router.mjs

@@ -137,18 +137,26 @@ export function readComposerSkillDetail(packageRoot, workspaceRoot, keyOrName) {
   return registryReadSkillDetail(packageRoot, workspaceRoot, keyOrName);
 }
 
+function skillNameFromKey(keyOrName) {
+  const value = String(keyOrName || "").trim();
+  if (!value) return "";
+  const idx = value.indexOf(":");
+  return idx >= 0 ? value.slice(idx + 1).trim() : value;
+}
+
 export function loadResourcesForSkillKeys(skillKeys, packageRoot, workspaceRoot) {
   if (!Array.isArray(skillKeys) || skillKeys.length === 0) {
     return { skills: [], references: [], skillsHint: "", hasContext: false };
   }
   const wanted = new Set(skillKeys.map((x) => String(x || "").trim()).filter(Boolean));
   if (wanted.size === 0) return { skills: [], references: [], skillsHint: "", hasContext: false };
+  const wantedNames = new Set(Array.from(wanted).map(skillNameFromKey).filter(Boolean));
 
   const exactByKey = new Map(registryListSkills(packageRoot, workspaceRoot).map((item) => [item.key, item]));
   const candidateItems = [];
   const seenKeys = new Set();
   for (const item of registryListUniqueSkills(packageRoot, workspaceRoot)) {
-    if (!wanted.has(item.key) && !wanted.has(item.name)) continue;
+    if (!wanted.has(item.key) && !wanted.has(item.name) && !wantedNames.has(item.name)) continue;
     candidateItems.push(item);
     seenKeys.add(item.key);
   }

package/bin/lib/paths.mjs

@@ -49,6 +49,11 @@ export function getAgentflowDataRootOverride() {
   return expandAgentflowHomePath(config.dataRoot || "");
 }
 
+export function getAgentflowSkillsRootOverride() {
+  const config = readAgentflowHomeConfig();
+  return expandAgentflowHomePath(config.skillsRoot || "");
+}
+
 export function writeAgentflowDataRootOverride(dataRoot) {
   const nextRoot = expandAgentflowHomePath(dataRoot);
   if (nextRoot && !path.isAbsolute(nextRoot)) {
@@ -62,6 +67,19 @@ export function writeAgentflowDataRootOverride(dataRoot) {
   return nextRoot;
 }
 
+export function writeAgentflowSkillsRootOverride(skillsRoot) {
+  const nextRoot = expandAgentflowHomePath(skillsRoot);
+  if (nextRoot && !path.isAbsolute(nextRoot)) {
+    throw new Error("skillsRoot must be an absolute path");
+  }
+  const current = readAgentflowHomeConfig();
+  const next = { ...current, skillsRoot: nextRoot };
+  if (!nextRoot) delete next.skillsRoot;
+  fs.mkdirSync(path.dirname(AGENTFLOW_HOME_CONFIG_PATH), { recursive: true });
+  fs.writeFileSync(AGENTFLOW_HOME_CONFIG_PATH, JSON.stringify(next, null, 2) + "\n", "utf-8");
+  return nextRoot;
+}
+
 export function getAgentflowDataRoot() {
   const env = process.env.AGENTFLOW_HOME;
   if (env != null && String(env).trim() !== "") {
@@ -72,6 +90,16 @@ export function getAgentflowDataRoot() {
   return path.join(os.homedir(), "agentflow");
 }
 
+export function getAgentflowSkillsRoot() {
+  const env = process.env.AGENTFLOW_SKILLS_ROOT;
+  if (env != null && String(env).trim() !== "") {
+    return expandAgentflowHomePath(env);
+  }
+  const configured = getAgentflowSkillsRootOverride();
+  if (configured) return configured;
+  return path.join(getAgentflowDataRoot(), "skills");
+}
+
 export const AGENTFLOW_DEFAULT_USER_ID = "";
 
 export function sanitizeAgentflowUserId(userId) {

package/bin/lib/skill-registry.mjs

@@ -2,6 +2,7 @@ import fs from "fs";
 import os from "os";
 import path from "path";
 import yaml from "js-yaml";
+import { getAgentflowSkillsRoot } from "./paths.mjs";
 
 const fileCache = new Map();
 const CACHE_TTL_MS = 60_000;
@@ -9,10 +10,11 @@ const SOURCE_PRIORITY = new Map([
   ["workspace-agents", 100],
   ["workspace-codex", 95],
   ["workspace-cursor", 90],
+  ["agentflow-root", 85],
   ["builtin", 80],
-  ["global-agents", 70],
-  ["global-codex", 65],
-  ["global-cursor", 60],
+  ["global-agents", 55],
+  ["global-codex", 50],
+  ["global-cursor", 45],
 ]);
 
 function readFileCached(absPath) {
@@ -28,6 +30,10 @@ function readFileCached(absPath) {
   }
 }
 
+export function clearSkillRegistryCache() {
+  fileCache.clear();
+}
+
 export function stripSkillFrontmatter(content) {
   const raw = String(content || "");
   const match = raw.match(/^---\s*\r?\n[\s\S]*?\r?\n---\s*\r?\n?/);
@@ -109,11 +115,17 @@ export function defaultSkillSources(packageRoot, workspaceRoot) {
     },
   ];
   if (workspaceRoot) sources.push(...workspaceSkillSources(workspaceRoot, "workspace", "工作区"));
+  sources.push({
+    source: "agentflow-root",
+    sourceLabel: "AgentFlow Skills",
+    dir: getAgentflowSkillsRoot(),
+    installedBy: "agentflow-admin",
+  });
   const home = os.homedir();
   sources.push(
-    { source: "global-agents", sourceLabel: "全局 .agents", dir: path.join(home, ".agents", "skills"), installedBy: "global" },
-    { source: "global-cursor", sourceLabel: "全局 .cursor", dir: path.join(home, ".cursor", "skills"), installedBy: "global" },
-    { source: "global-codex", sourceLabel: "全局 .codex", dir: path.join(home, ".codex", "skills"), installedBy: "skillhub" },
+    { source: "global-agents", sourceLabel: "Legacy ~/.agents", dir: path.join(home, ".agents", "skills"), installedBy: "global" },
+    { source: "global-cursor", sourceLabel: "Legacy ~/.cursor", dir: path.join(home, ".cursor", "skills"), installedBy: "global" },
+    { source: "global-codex", sourceLabel: "Legacy ~/.codex", dir: path.join(home, ".codex", "skills"), installedBy: "skillhub-legacy" },
   );
   return sources;
 }
@@ -183,9 +195,10 @@ export function listUniqueSkills(packageRoot, workspaceRoot, opts = {}) {
 export function readSkillDetail(packageRoot, workspaceRoot, keyOrName) {
   const wanted = String(keyOrName || "").trim();
   if (!wanted) return null;
+  const wantedName = wanted.includes(":") ? wanted.slice(wanted.indexOf(":") + 1).trim() : wanted;
   const all = listSkills(packageRoot, workspaceRoot);
   const item = all.find((skill) => skill.key === wanted)
-    || dedupeSkillsByName(all).find((skill) => skill.name === wanted);
+    || dedupeSkillsByName(all).find((skill) => skill.name === wanted || skill.name === wantedName);
   if (!item) return null;
   return item;
 }